\documentclass [12pt, a4paper]{report}

\usepackage[pdftex]{graphicx}
\usepackage[ascii]{inputenc}
\usepackage[spanish]{babel}
\usepackage{amssymb}
\setcounter{tocdepth}{3}

\begin{document}

%CARATULA-------------------------------------------------------------------------------------------------------------------
\title{Compilador C - -}

\author{Martinelli, Fern\'an Gabriel;
	Riberi, Franco Gaspar;
	Varea, Agust\'in}

\date{\today} 

\maketitle

\newpage


\pagenumbering{roman} %numeracion romana
%SUBCARATULA------------------------------------------------------------------------------------------------------------------
\pagebreak
\begin{center}
	{ \textbf{UNIVERSIDAD NACIONAL DE R\'IO CUARTO}}% 
        \vskip 0.25cm    
	{Facultad de Ciencias Exactas, F\'isica-Qu\'imicas y Naturales}%
        \vskip 0.25cm    
	{Departamento de Computaci\'on}%
        \vskip 0.25cm    
	{(http://dc.exa.unrc.edu.ar/principal)}%
        \vskip 2.5cm    
\end{center}%

\begin{figure}[ht]
\begin{center}
\includegraphics[width=1.1638in,height=1.3744in]{image/unrc.png}
\end{center}
\end{figure}

\vskip 1cm    

\begin{center}
	\textbf{Informe de Proyecto: Implementaci\'on de un Compilador}
\end{center}

\vskip 6cm    
\begin{center}%
    \normalfont
        {Taller de Dise\~no de Software / Compiladores 2011 }%
	\vskip 0.25cm
	{C\'odigo 3306}%
	\vskip 0cm
\end{center}%
	
\pagenumbering{arabic}
%RESUMEN---------------------------------------------------------------------------------------------------------------------------------
\newpage
\begin{abstract} 
Se presentar\'a un compilador para un subconjunto de estructuras del conocido lenguaje de prograci\'on C, llamado C - -. Se describir\'an las distintas etapas por las cuales se atravezaron durante el dise\~no y desarrollo del mismo, partiendo por el an\'alisis l\'exico de un secuencia de caracteres tomados por entrada est\'andar o le\'idos desde un archivo y finalizando en un c\'odigo assembly, pasando por el an\'alisis sint\'actico y sem\'antico, adem\'as de las representaciones internas y las distintas optimizaciones. Este proyecto contempla diversos conceptos previos, tales como gram\'aticas regulares, expresiones regulares, aut\'omatas, entre otros. \\
El lenguaje de implementaci\'on utilizado para el mencionado compilador fue C, bajo el sistema operativo Linux. Se utilizaron adem\'as diversas herramientas auxiliares, tales como Lex y Yacc para el an\'alisis l\'exico y sint\'actico (LR) respectivamente. Adem\'as se utiliz\'o c\'odigo de tres direcciones como lenguaje intermedio y se manej\'o un assembly x86.

\end{abstract}

%INDICE GENERAL---------------------------------------------------------------------------------------------------------------------------------
\newpage
\tableofcontents %indice de contenidos

%INDICE DE FIGURAS------------------------------------------------------------------------------------------------------------------------------
\newpage
\listoffigures

\newpage
\section*{Introducci\'on}
Los lenguajes de programaci\'on son notaciones que describen los c\'alculos a las personas y las m\'aquinas. La percepci\'on del mundo en que vivimos depende de los lenguajes de programaci\'on, ya que todo software que se ejecuta en una computadora se escribi\'o en alg\'un lenguaje de programaci\'on. Pero antes de poder ejecutar un programa, primero debe traducirse a un formato en el que una computadora pueda ejecutarlo. Los sistemas de software que se encargan de esta traducci\'on se denominan \textbf{compiladores}.
A grandes rasgos un compilador es un programa que puede leer otro programa escrito en un lenguaje (en lenguaje fuente) y traducirlo en un programa equivalente.

El presente documento forma parte del proyecto de c\'atedra correspondiente a la materia Taller de Dise\~no de Software (c\'odigo 3306) dictada por el Departamento de Computaci\'on de la Universidad Nacional de R\'io Cuarto. Tiene como objetivo el desarrollo de un compilador para el lenguaje de programaci\'on C - -, atravesando todas las etapas necesarias para tal fin. El trabajo se abord\'o de manera incremental, donde en cada etapa se a\~nade a la anterior una nueva parte del compilador. El producto de este proyecto debe poder aceptar algoritmos simples escritos en C - -, y producir un assembly para alguna computadora.

Tal documento est\'a formado por X cap\'itulos los cuales reflejan el camino transitado. En el cap\'itulo 1 se explicar\'a con m\'as detalles qu\'e es un compilador y c\'omo esta formado. Adem\'as se explicar\'an otras herramientas para la construcci\'on de programas, tales como int\'erpretes y enlazadores (linkers).
En el cap\'itulo 2 se contemplan las primeras dos etapas de un compilador, es decir, el an\'alisis l\'exico y an\'alisis sint\'actico.
. \\
. \\
. \\
. \\
A continuaci\'on se presenta dicho trabajo. \\

\newpage
\chapter{Conceptos Previos} 
A continuaci\'on se presentar\'an conceptos te\'oricos que brindaran al lector la capacidad de comprender los temas abordados en los
pr\'oximos cap\'itulos, ya que se utilizar\'a un lenguaje no necesariamente natural.

\section{Compiladores}
Un compilador puede considerarse como una simple caja que mapea un programa fuente a un programa destino con equivalencia sem\'antica, como se observa en la Figura~\ref{1}.

\begin{figure}[ht]
\begin{center}
\includegraphics[width=1.1638in,height=1.3744in]{image/1.png}
\caption{Un compilador}
\label{1}
\end{center}
\end{figure}

Si inspeccionamos esta caja podemos observar que existen dos procesos importantes: an\'alisis y s\'intesis. 
La parte de \textbf{an\'alisis} (front-end) divide el programa fuente en componentes e impone una estructura gramatical sobre ellas. Luego utiliza esta estructura para crear una representaci\'on intermedia del programa fuente. Adem\'as esta etapa recolecta informaci\'on sobre el programa fuente y la almacena en una estructura de datos (tabla de s\'imbolos), la cual se pasa junto a la representaci\'on intermna a la parte de s\'intesis.
La parte de \textbf{s\'intesis} (back-end) construye el programa destino deseado a partir de la entrada provista por la parte de an\'alisis.
M\'as detalladamente, se puede observar que un compilador opera como una secuencia de fases, donde cada una de ellas transforma un representaci\'on del programa en otra. Estas fases se exhiben en la Figura~\ref{2}.

\begin{figure}[ht]
\begin{center}
\includegraphics[width=4.0638in,height=3.7744in]{image/2.png}
\caption{Fases de un compilador}
\label{2}
\end{center}
\end{figure}

En los posteriores cap\'itulos se detallaran estas fases, aplicadas al lenguaje C - -. 
Dado a que los conceptos relacionados con int\'erpretes y enlazadores son poco redundantes para este proyecto, se deja a criterio del lector inspeccionar \'estos temas [1].

\section{El lenguaje C - -}
En t\'erminos generales, C - - es un subconjunto del conocido lenguaje de programaci\'on C. La estructura y significado de las construcciones del lenguaje C - - se tratan en el Ap\'endice A.
 

\newpage
\chapter{Etapas del Desarrollo}
A continuaci\'on abordaremos las distintas etapas por las que se atravezaron para el desarrollo del mencionado compilador.

\section{An\'alisis L\'exico}
La principal tarea de este an\'alisis, tambi\'en conocido como \textbf{escaneo}, consiste en leer los caracteres de la entrada del programa fuente, agruparlos en lexemas y producir como salida una secuencia de tokens para cada lexema en el programa fuente. El flujo de tokens se env\'ia al analizador sint\'actico para su an\'alisis. Adem\'as, con frecuencia puede interactuar con la tabla de s\'imbolos, esto es, si descubre un lexema que constituye a un identificador, debe almacenar ese lexema en la estructura de datos. En algunos casos, el analizador l\'exico puede leer la informaci\'on de la tabla de s\'imbolos para determinar el token apropiado que debe pasar al analizador sint\'actico. En la Figura~\ref{4} se puede observar la interacci\'on descripta anteriormente.

\begin{figure}[ht]
\begin{center}
\includegraphics[width=4.7638in,height=1.8744in]{image/4.png}
\caption{Interacci\'on analizador l\'exico y analizador sint\'actico}
\label{4}
\end{center}
\end{figure}

Dentro de las tareas que debe realizar un an\'alizador l\'exico debemos mencionar la eliminaci\'on de comentarios y de espacios en blancos (caracteres de espacio, nueva l\'inea, tabulador, etc\'etera). Adem\'as debe correlacionar los mensajes de error generados por el compilador con el programa fuente.
Algunas veces, los analizadores l\'exicos se dividen en dos procesos:
\begin{itemize}
\item \textbf{Escaneo}, consiste en los procesos simples que no requieren la determinaci\'on de tokens de la entrada.
\item \textbf{An\'alisis l\'exico} propiamente dicho, consiste en la producci\'on de los tokens de salida.
\end{itemize}


\subsection{Tokens, Patrones y Lexemas}
Un \textbf{Token} es un par que consiste en un nombre de token y un valor de atributo opcional. El primer componente (nombre-token) es un s\'imbolo abstracto que representa un tipo de unidad l\'exica, y el segundo componente (valor-atributo) apunta a una nueva entrada en la tabla de s\'imbolos para este token. Esta informaci\'on es necesaria para el an\'alisis sem\'antico y la generaci\'on de c\'odigo. Tambi\'en es \'util para determinar que token es el adecuado, en caso que m\'as de un lexema pueda coinsidir con un patr\'on.

Un \textbf{Patr\'on} es una descripci\'on de la forma que pueden tomar los lexemas de un token. En el caso de una palabra clave como token, el patr\'on es s\'olo la secuencia de caracteres que la conforman, en cambio, para identificadores u otros tokens, puede ser necesario estructuras m\'as complejas.

Un \textbf{Lexema} es una secuencia de caracteres en el programa fuente, que coinciden con el patr\'on para un token y que el analizador l\'exico identifica como una instancia de ese token.


Por ejemplo: supongamos que la siguiente frase forma parte de un programa fuente: \textbf{pos = init + vel * 60}. \\
Los caracteres podr\'ian agruparse en los siguiente lexemas:

\begin{itemize}
\item \textbf{pos} es un lexema que se asigna a un token {\textless}\textit{id,1}{\textgreater}, donde id representa la palabra identificador y 1 apunta a la entrada en la tabla de s\'imbolos para pos. 
\item \textbf{=} es un lexema que se asigna al token {\textless}\textit{=}{\textgreater}. Dado a que este token no necesita un valor, se omite el segundo componente.
\item \textbf{init} es un lexema que se asigna al token {\textless}\textit{id,2}{\textgreater}, con el mismo significado que pos.
\item \textbf{+} es un lexema que se asigna al token {\textless}\textit{+}{\textgreater}.
\item \textbf{vel} es un lexema que se asigna al token {\textless}\textit{id,3}{\textgreater}, con el mismo significado que pos.
\item \textbf{*} es un lexema que se asigna al token {\textless}\textit{*}{\textgreater}.
\item \textbf{60}  es un lexema que se asigna al token {\textless}\textit{60}{\textgreater} \footnote{T\'ecnicamente, para el lexema 60 deber\'iamos formar un token como {\textless}\textit{numero,4}{\textgreater}}. 
\end{itemize}

De esta forma, la representaci\'on despu\'es del analizador l\'exico ser\'ia:

{\textless}\textit{id,1}{\textgreater} {\textless}\textit{=}{\textgreater} {\textless}\textit{id,2}{\textgreater} {\textless}\textit{+}{\textgreater} {\textless}\textit{id,3}{\textgreater} {\textless}\textit{*}{\textgreater} {\textless}\textit{60}{\textgreater}

\subsection{Errores L\'exicos}
Es muy dif\'icil detectar errores en el c\'odigo fuente desde este an\'alisis, ya que por ejemplo si la cadena \textit{fi} se encuentra por primera vez en un programa C en el contexto: fi (a == f(x)), no se puede determinar si fi es una palabra if mal escrita, o un indentificador de una funci\'on no declarada. Supongamos que fi es un lexema v\'alido para el token id, el analizador l\'exico debe retornar el token id, y dejar que en otra fase del compilador se resuelva esto.
Si en alg\'un momento el analizador no puede proceder, ya que ninguno de los patrones para los token coinside con alg\'un prefijo de la entrada, se puede optar por alguna estrateg\'ia de recuperaci\'on. Algunas de ellas son: recuperaci\'on en modo de p\'anico \footnote{Es la estrateg\'ia de recuperaci\'on m\'as simple} (eliminamos caracteres sucesivos hasta que se pueda encontrar un token bien formado), eliminar un car\'acter del resto de la entrada, insertar un car\'acter faltante en el resto de la entrada, sustituir un car\'acter por otro, transponer dos caracteres adyacentes, entre otras.

\subsection{Resoluci\'on de conflicto Lex}
Para decidir el lexema correcto cuando varios prefijos de la entrada coinciden con uno o m\'as patrones, Lex utiliza alguna de las siguientes reglas:
\begin{itemize}
\item Preferir siempre un prefijo m\'as largo a uno m\'as corto.
\item Si el prefijo m\'as largo posible coincide con dos o m\'as patrones, preferir el patr\'on que se lista primero en el programa Lex.
\end{itemize}

\subsection{An\'alisis Lexico Compilador C - -}

En esta subsecci\'on daremos un pantallazo acerca de la herramienta Lex (o Flex) que nos permiti\'o especificar un analizador l\'exico mediante la especificaci\'on de expresiones regulares [2] para describir patrones de los tokens.
B\'asicamente es una herramienta de los sistemas UNIX/Linux que permite generar c\'odigo C, que luego podemos compilar y enlazar con nuestro programa. La principal caracter\'istica de Lex es que nos va a permitir asociar acciones descriptas en C, a la localizaci\'on de las expresiones regulares que definimos previamente. Internamente Lex actua como un aut\'omata que localizar\'a las expresiones regulares que describimos, y una vez reconocida la cadena representada por dicha expresi\'on regular, ejecutar\'a el c\'odigo asociado a esa regla.
En la Figura~\ref{5} se observa c\'omo se utiliza Lex. Toma como entrada un archivo .l escrito en un lenguaje Lex. El compilador Lex transforma este archivo en un programa C (que simula un diagrama de transiciones), en un archivo llamado \textbf{lex.yy.c}. El compilador de C luego transforma este \'ultimo archivo en un programa ejecutable a.out.

\begin{figure}[ht]
\begin{center}
\includegraphics[width=4.0638in,height=1.7744in]{image/5.png}
\caption{Creaci\'on de un analizador l\'exico con Lex}
\label{5}
\end{center}
\end{figure}

\subsubsection{Estructura de un archivo Lex}
Un programa Lex tiene la siguiente forma:
\begin{verbatim}
	declaraciones
	%%
	reglas de traducción
	%%
	funciones auxiliares
\end{verbatim}
La secci\'on \textit{declaraciones} incluye la declaraci\'on de variables, constantes, etc\'etera. La secci\'on \textit{reglas de traducci\'on} incluye reglas de la forma: Patr\'on {acci\'on}, donde cada patr\'on corresponde a una expresi\'on regular, las cuales pueden usar las definiciones regulares de la secci\'on anterior. Las acciones son fragmentos de c\'odigo, que indican que hacer cuando el se encuentre un lexema que coincidente con el patr\'on. Por \'ultimo, la secci\'on \textit{funciones auxiliares}, contiene funciones adicionales que se usan en las acciones.

Para generar el analizador l\'exico para el lenguaje C - -, creamos un archivo llamado anLexico.l, el cual tiene la misma estrcutura que la mencionada anteriormente. 
En la primera secci\'on declaramos la incluci\'on de la biblioteca de C para el manejo de la entrada est\'andar (stdio.h) y definimos una variable llamada num\_lineas que permite llevar un contador de lineas, el cual ser\'a utilizado para indicar la cantidad de l\'ineas compiladas, y en caso de que el compilador posteriormente encuentre alg\'un error, esta variable permitir\'a establecer en que lugar se encontr\'o el mismo. Adem\'as creamos algunas definiciones regulares que permiten detectar ciertos lexemas.

En la segunda secci\'on de nuestro archivo Lex, definimos por cada patr\'on una acci\'on correspondiente al mismo, esto es, asociamos a cada patr\'on el token que el analizador l\'exico debe retornar, a excepci\'on de los patr\'ones utilizados para identificar los comentarios, saltos de lineas y tabulaciones, dado que necesitamos descartar los mismos.

Por \'ultimo, la tercera secci\'on permanece vac\'ia ya que no es necesario ning\'un tratamiento especial.
Para compilar este archivo y luego proveerle una cadena de entrada realizamos la siguiente secuencia de pasos:
\begin{verbatim}
	1- lex anLexico.l    (o flex)
	2- gcc lex.yy.c -o ejectuble
	3- ./ejecutable
\end{verbatim}
Cabe aclarar adem\'as, que en la primera secci\'on del archivo Lex, se incluyo \textbf{y.tab.h}, lo cual es un generador autom\'atico para Yacc (Bison), el cual ser\'a utilizado para realizar el an\'alisis sint\'actico. M\'as adelante se desarrollara detalladamente la relaci\'on entre Flex y Bison.


\section{An\'alisis Sint\'actico}
El an\'alizador sint\'actico debe obtener una cadena de tokens del analizador l\'exico, y verificar que la cadena pueda generarse mediante la gram\'atica para el lenguaje fuente. Este analizador debe construir un \'arbol de an\'alisis sint\'actico el cual debe ser pasado a la etapa de an\'alisis sem\'antico. Este \'arbol no necesita construirse de manera expl\'icita.
Pueden mencionarse tres tipos de analizadores: 
\begin{itemize}
\item \textbf{Universales}, como el algoritmo de Earley [3], permiten analizar cualquier gram\'atica, aunque son demasiados ineficientes como para usarse en compiladores.
\item \textbf{Descendentes}, construyen el \'arbol de an\'alisis sint\'actico desde la parte superior (ra\'iz) hacia la parte inferior (hojas).
\item \textbf{Ascendentes},  construyen el \'arbol de an\'alisis sint\'actico partiendo desde las hojas hacia la ra\'iz.
\end{itemize}

\subsection{An\'alisis Sint\'actico del Compilador C - -}
Utilizamos un generador de analizadores sint\'acticos LALR llamado \textbf{Yacc}. En primera instancia se crea un archivo, por ejemplo arch.y, el cual contiene una especificaci\'on Yacc. Luego se transforma este archivo en un programa C llamado y.tab.c usando el m\'etodo LALR. Este \'ultimo programa es una representaci\'on del analizador sint\'actico LALR escrito en C. Luego debe compilarse el archivo y.tab.c junto a una libreria que contenga el programa de an\'alisis sint\'actico LR, para as\'i obtener el programa objeto, le cual realiza la traducci\'on especificada por el programa original en Yacc.

\begin{figure}[ht]
\begin{center}
\includegraphics[width=4.0638in,height=1.7744in]{image/6.png}
\caption{Creaci\'on de un analizador sint\'actico con Yacc}
\label{6}
\end{center}
\end{figure}


El proceso de compilaci\'on mencionado se realiza mediante lo siguiente:
\begin{verbatim}
	1- yacc arch.y    (o bison)
	2- gcc y.tab.c -ly
\end{verbatim}

Un programa fuente en Yacc esta formado por tres partes:
\begin{verbatim}
	declaraciones
	%%
	reglas de traduccion
	%%	
	soporte de las rutinas en C
\end{verbatim}
La secci\'on \textit{declaraciones} esta compuesta por dos partes, ambas opcionales, en una colocamos las declaraciones ordinarias de C, delimitadas por \%{ y \%}, adem\'as de las declaraciones de cualquier valor temporal. En la otra, declaramos los tokens de la gram\'atica.
La secci\'on \textit{reglas de traducci\'on} corresponde a un conjunto de reglas, donde cada una de ellas consiste en una producci\'on gramatical y la acci\'on sem\'antica asociada a ella. Aqu\'i las cadenas sin comillas que no sean declaradas como token, ser\'an consideradas como no terminales.
%Una acci\'o sem\'antica de Yacc es una secuencia de instrucciones en C. En una acci\'on sem\'antica, el s\'imbolo $$ se refiere al valor del atributo asociado con el no terminal del encabezado, mientras que $i se refiere al valor asociado con el i-\'esimo s\'imbolo gramatical (terminal o no terminal) del cuerpo. La acci\'on sem\'antica se realiza cada vez que reducimos mediante la producci\'on asociada, por lo que normalmente la acci\'on sem\'antica calcula un valor para $$ en t\'erminos de los $i's.
La secci\'on \textit{rutinas de C} consiste en un conjunto de rutinas necesarias. Debe proporcionarse un analizador l\'exico mediante en nombre \textbf{yylex()}. Adem\'as pueden agregarse rutinas por ejemplo para la recuperaci\'on de errores. \\

Para generar el analizador sint\'actico para el compilador de C - -, se cre\'o un archivo llamado anSintactico.y, el cual respecta una estructura id\'entica a la mencionada anteriormente.
En la primera secci\'on, al igual que en el archivo Lex, definimos las librerias necesarias dentro de las cuales encontramos stdio.h para el manejo de la entrada est\'andar, y stdlib.h para el manejo de la ejecuci\'on del programa yacc. Adem\'as definimos una variable como ``extern'', la cual corresponde a la variable num\_lineas definidas anteriormente en el Lex. Dado a que se utiliz\'o Lex para crear el analizador l\'exico que genera los diferentes tokens, en el archivo yacc se deben definir expl\'icitamente los nombres de todos los tokens que son resultantes de la etapa anterior. Aquellos token que corresponden a caracteres (por ejemplo '=', ':', '?', ')', entre otros) no necesitan declararse dado a que yacc los toma como tokens por defecto. Por \'ultimo, en esta primera secci\'on definimos el s\'imbolo inicial de la gram\'atica, a partir del cual se comenzar\'a a ejecutar, adem\'as se puede declarar la presedencia entre los operadores (si es necesario). \\
En la segunda secci\'on se defin\'o la gram\'atica propiamente dicha, la cual incluye diferentes reglas que abarcan toda la estructura del lenguaje C - -. \\
En la tercera secci\'on definimos el comportamiento del programa, es decir, definimos todas aquellas funciones necesarias para controlar el flujo de ejecuci\'on. 

Definimos una funci\'on llamada yyerror, la cual ser\'a invocada por el parser en caso de detectar un error, la cual informar\'a en que l\'inea se encontr\'o el dicho error (utilizando la variable ya mencionada). 
Definimos tambi\'en un main, el cual permite tomar como entrada un archivo con extensi\'on .c-, en caso de que el archivo no exista o no tenga la extensi\'on correcta se informa por pantalla dicha eventualidad, en caso contrario se invoca la funci\'on yyparse() la cual ejecuta el parser utilizando la gram\'atica antes definida. Si el c\'odigo C - - perteneciente al archivo procesado no presenta errores, el an\'alisis sint\'actico ser\'a exitoso, esto quiere decir, que se pudo armar el \'arbol sint\'actico de derivaci\'on. \'Este es una representaci\'on intermedia que pasar\'a a la siguiente etapa del compilador.


\subsection{Interconexi\'on entre Lex e Yacc}
Cuando el analizador sint\'actico llama al analizador l\'exico, \'este empieza a leer la entrada, un car\'acter a la vez, hasta que encuentra el prefijo m\'as largo de la entrada que coincide con uno de los patrones Pi. Despu\'es ejecuta la acci\'on Ai asociada. Por lo general Ai regresar\'a al analizador sint\'actico, pero si no lo hace (por ejemplo para descargar saltos de l\'inea) el analizador l\'exico procede a buscar lexemas adicionales, hasta que una de las acciones correspondientes provoque un retorno al analizador sint\'actico. El analizador l\'exico devuelve al sint\'actico un solo valor, el nombre del token, pero utiliza la variable entera compartida \textbf{yylval} para pasarle la informaci\'on adicional sobre el lexema encontrado, si es necesario.

\subsection{Comparaci\'on entre el an\'alisis l\'excio y an\'alisis sint\'actico}
Existen varias razones por las cuales cuales estos an\'alisis se hacen por separado. Algunas de ellas son:
\begin{itemize}
\item La sencillez en el dise\~no.
\item Eficiencia.
\item Portabilidad.
\end{itemize}

\section{An\'alisis Sem\'antico}
\section{Generador de C\'odigo Intermedio}
\section{Generaci\'on de C\'odigo Objeto para Enteros}
\section{Generaci\'on de C\'odigo Objeto para Reales}
\section{Optimizaciones}

\newpage
\chapter{Conclusiones}

\newpage
\chapter{Referencias Bibiogr\'aficas}

[1] Lenguajes de programaci\'on y modelos de computaci\'on. Marcelo Daniel Arroyo. 2009 \\

[2] Regular expression and state graphs for automata. McNaugton R. y H.Yamada. 1960. \\

[3] http://cuba.dc.uba.ar/w/Teor\'ia\_de\_Lenguajes \\

[4] P\'agina inicial de Flex, http://www.gnu.org/software/flex/, Fundaci\'on de software libre \\


\newpage
\appendix
\noindent
\textbf{AP\'ENDICE \\}
\\
A \\

\section{Definici\'on de C- -}
A continuaci\'on se especifica mediante diagramas la estructura y el significado de los componentes del lenguaje.
 
\subsection{S\'imbolos B\'asicos}
Son los componentes individuales del lenguaje, su significado coincide con el de los dem\'as lenguajes. Podemos encontrar identificadores (Figura~\ref{identificadores}), denotacionales (Figura~\ref{intDenotacional} y Figura~\ref{floatDenotacional}) y delimitadores. 

\begin{figure}[ht]
\begin{center}
\includegraphics[width=3.0638in,height=0.9744in]{image/identificador.png}
\caption{Identificadores}
\label{identificadores}
\end{center}
\end{figure}

\begin{figure}[ht]
\begin{center}
\includegraphics[width=3.0638in,height=0.9744in]{image/intDenotacional.png}
\caption{IntDenotacional}
\label{intDenotacional}
\end{center}
\end{figure}

\begin{figure}[ht]
\begin{center}
\includegraphics[width=5.5638in,height=1.5744in]{image/flaotDenotacional.png}
\caption{FlaotDenotacional}
\label{floatDenotacional}
\end{center}
\end{figure}

El conjunto \textit{letter} incluye todas las may\'usculas y min\'usculas del alfabeto, adem\'as del caracter (\_). Se distingue entre may\'usculas y min\'usculas. Los comentarios son secuencias arbitrarias de caracteres que comienzas con /* y terminan con */. \\
Los delimitadores de C - - son los siguientes caracteres o palabras claves:
\begin{verbatim}
+		(		!		&&		<		/		}		if		else		while		%		||		,		*		{		:		;		continue		return		=		-		)		?		==		>		break		int	  	floar
\end{verbatim}

\subsection{Estructura de un Programa}
Un programa se ejecuta mediante la lectura de los valores de los par\'ametros de la unidad de entrada est\'andar y la ejecuci\'on del componente Compound. El retorno debe ser ejecutado para terminar el programa.

\begin{figure}[ht]
\begin{center}
\includegraphics[width=6.0638in,height=0.7744in]{image/program.png}
\caption{Estructura de un programa}
\end{center}
\end{figure}

\begin{figure}[ht]
\begin{center}
\includegraphics[width=5.0638in,height=0.95744in]{image/compound.png}
\caption{Componente Compound}
\end{center}
\end{figure}

\vskip 5cm
\subsection{Declaraciones}
\begin{figure}[ht]
\begin{center}
\includegraphics[width=3.0638in,height=0.6044in]{image/ParameterDecl.png}
\caption{Declaraci\'on de par\'ametros}
\end{center}
\end{figure}

\begin{figure}[ht]
\begin{center}
\includegraphics[width=4.8638in,height=0.95744in]{image/variableDecl.png}
\caption{Declaraci\'on de variable}
\end{center}
\end{figure}

\begin{figure}[ht]
\begin{center}
\includegraphics[width=2.5638in,height=0.95744in]{image/typeSpecifier.png}
\caption{Declaraci\'on de tipo}
\end{center}
\end{figure}

\vskip 20cm
\subsection{Estados}
\begin{figure}[ht]
\begin{center}
\includegraphics[width=5.5638in,height=3.95744in]{image/statement.png}
\caption{Declaraci\'on estados}
\end{center}
\end{figure}

\begin{figure}[ht]
\begin{center}
\includegraphics[width=5.5638in,height=0.75744in]{image/conditional.png}
\caption{Declaraci\'on del condicional}
\end{center}
\end{figure}

\begin{figure}[ht]
\begin{center}
\includegraphics[width=5.5638in,height=0.75744in]{image/iteration.png}
\caption{Declaraci\'on del iterador}
\end{center}
\end{figure}

\begin{figure}[ht]
\begin{center}
\includegraphics[width=3.5638in,height=0.45744in]{image/computation.png}
\caption{Declaraci\'on de un calculo}
\end{center}
\end{figure}

\vskip 10cm
\subsection{Expresiones}
\begin{verbatim}
	Expression  --> Identifier '=' Expression | Condition
	Condition   --> Disjuntion | Disjuntion '?' Expression ':' Condition
	Disjuntion  --> Conjunction | Disjuntion '||' Conjunction   	
	Conjunction --> Comparison | Conjunction '&&' Comparison
	Comparison  --> Relation | Relation '==' Relation
	Relation    --> Sum | Sum ('<'|'>') Sum
	Sum         --> Term | Sum ('+'|'-') Term
	Term	    --> Factor | Term ('*'|'/'|'%') Factor
	Factor      --> Primary | ('!'|'-') Factor
	Primary	    --> IntDenotation | FloatDenotation | Identifier | '(' Expression ')'
\end{verbatim}



\end{document}





